home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / Xpm / pixmap / PortEditor.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  26KB  |  983 lines
  1. /*
  2.  * $Id: PortEditor.c,v 1.3 1992/10/28 12:28:44 mallet Exp $
  3.  *
  4.  * Copyright 1992 Lionel Mallet
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appears in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of Lionel MALLET not be used in
  11.  * advertising or publicity pertaining to distribution of the software
  12.  * without specific, written prior permission.  Lionel MALLET makes no
  13.  * representations about the suitability of this software for any
  14.  * purpose.  It is provided "as is" without express or implied warranty.
  15.  *
  16.  * Lionel MALLET DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17.  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  18.  * FITNESS, IN NO EVENT SHALL Lionel MALLET BE LIABLE FOR ANY SPECIAL,
  19.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  20.  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  21.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23.  *
  24.  *  This software is opened and free. Furthermore, everybody is kindly
  25.  * invited to participate to improve it for the benefit of all.
  26.  * Improvements can be new features, bugs fixes and porting issues
  27.  * resolution.
  28.  *
  29.  * Author:  Tim Wise - Scientific & Engineering Software (SES), Inc.
  30.  */
  31.  
  32. #include <string.h>
  33.  
  34. Boolean _PORTDEBUG = False;
  35.  
  36.  
  37. /*--------------------------------------------------------------------------*/
  38. /*
  39.             p o r t E d i t o r B u t t o n s
  40.  
  41.     Buttons for port editor.
  42. */
  43. /*--------------------------------------------------------------------------*/
  44.  
  45. static ButtonRec portEditorButtons[] = {
  46.  
  47. /* buttons ids */
  48.  
  49. #define kSetPort    0
  50. #define kClearPort    1
  51. #define kMovePort    2
  52. #define kPortInfo    3
  53.  
  54.   /* button recs  */
  55.   /* id,       name,        trap,   widget */
  56.  
  57.   { kSetPort,   "setPort",   TOGGLE, NULL },
  58.   { kClearPort, "clearPort", TOGGLE, NULL },
  59.   { kMovePort,  "movePort",  TOGGLE, NULL },
  60.   { kPortInfo,  "portInfo",  TOGGLE, NULL }
  61.  
  62. }; /* portEditorButtons */
  63.  
  64.  
  65.  
  66. /*****************************************************************************/
  67. /*
  68.             Port List Routines 
  69.  
  70.     A list of ports is kept in the XpmExtension format which is an
  71.     array of strings, one for each port. Convert string format
  72.     to Port structure when needed.
  73. */
  74. /*****************************************************************************/
  75.  
  76.  
  77. #define XpmPortName    "Ports"
  78. #define UNKNOWN        -1
  79.  
  80. typedef struct {
  81.     int       id;        /* unique number */
  82.     Position  x;        /* location of port */
  83.     Position  y;
  84.     char      info[256];     /* port info: name, kind */
  85. } Port;
  86.  
  87.  
  88. /*--------------------------------------------------------------------------*/
  89. /*
  90.             N e w P o r t 
  91.  
  92.     Allocate a new port structure including a string for info.
  93.     Return a pointer to allocated structure.
  94. */
  95. /*--------------------------------------------------------------------------*/
  96. Port *NewPort()
  97. {
  98.     Port *p;
  99.  
  100.     p = (Port *) XtNew(Port);
  101.     if (p != NULL) {
  102.         p->id = UNKNOWN;
  103.         p->x  = UNKNOWN;
  104.         p->y  = UNKNOWN;
  105.         p->info[0] = '\0';
  106.     }
  107.     return  p;
  108. }
  109.  
  110.  
  111. /*--------------------------------------------------------------------------*/
  112. /*
  113.             S t r T o P o r t
  114.  
  115.     Convert a string to a port structure. Return a pointer to the
  116.      port structure. NOTE: Caller must free structure!!
  117. */
  118. /*--------------------------------------------------------------------------*/
  119. Boolean StrToPort( str, p )
  120.     char *str;
  121.     Port *p;
  122. {
  123.     char *s, *t;
  124.     int  x, y;
  125.  
  126.     if (str != NULL && p != NULL) {
  127.  
  128.         sscanf( str, "%d%d%d",&p->id, &x, &y );
  129.         p->x = (Position) x;
  130.         p->y = (Position) y;
  131.         p->info[0] = '\0';
  132.  
  133.     s = XtMalloc( strlen(str) + 1 );    
  134.         strcpy( s, str );
  135.         t = strtok( s, " ," );         /* first token  id */
  136.         t = strtok( NULL, " ," );    /* second token x  */
  137.         t = strtok( NULL, " ," );    /* third token  y  */
  138.  
  139.         if (t != NULL && t+strlen(t)+1 < s+strlen(str)) 
  140.             strcpy( p->info, t+strlen(t)+1 );/* stuff after tokens */
  141.         
  142.         return True;
  143.  
  144.     } else 
  145.         return False;
  146. }
  147.  
  148.  
  149. /*--------------------------------------------------------------------------*/
  150. /*
  151.             P o r t T o S t r
  152.  
  153.     Convert a port structure to a string. Return pointer to string.
  154.     Caller must free string.
  155. */
  156. /*--------------------------------------------------------------------------*/
  157. char *PortToStr( p )
  158.     Port *p;
  159. {
  160.     char id_str[40];
  161.     char x_str[40];
  162.     char y_str[40];
  163.     char *str = NULL;
  164.  
  165.     if (p != NULL) {
  166.         sprintf( id_str, "%d\0", p->id );
  167.         sprintf( x_str,  "%d\0", p->x );
  168.         sprintf( y_str,  "%d\0", p->y );
  169.     str = XtMalloc( strlen(x_str) + strlen(y_str) + strlen(id_str)
  170.                         + strlen(p->info) + 4 );
  171.         str[0] = '\0';
  172.         strcat( str, id_str  );
  173.         strcat( str, " "     );
  174.         strcat( str, x_str   );
  175.         strcat( str, " "     );
  176.         strcat( str, y_str   );
  177.         strcat( str, " "     );
  178.         strcat( str, p->info );
  179.     }
  180.     return str;
  181. }
  182.  
  183.  
  184. /*--------------------------------------------------------------------------*/
  185. /*
  186.             U p d a t e P o r t 
  187.  
  188.     Replace string version of port i with info given in port structure.
  189. */
  190. /*--------------------------------------------------------------------------*/
  191. void UpdatePort( ports, i, p )
  192.     XpmExtension *ports;
  193.     int          i;
  194.     Port         *p;
  195. {
  196.     XtFree( ports->lines[i] );
  197.     ports->lines[i] = PortToStr( p );
  198. }
  199.  
  200.  
  201. /*--------------------------------------------------------------------------*/
  202. /*
  203.             F i n d P o r t 
  204.  
  205.     Search a list of ports and find the first at location (x,y).
  206.     If found, return index of port; otherwise return UNKNOWN.
  207. */
  208. /*--------------------------------------------------------------------------*/
  209. int FindPort( ports, at_x, at_y )
  210.     XpmExtension *ports;
  211.     Position     at_x;
  212.     Position     at_y;
  213. {
  214.     int   i;
  215.     int   x;
  216.     int   y;
  217.     Port  p;
  218.  
  219.     if (strcmp(ports->name, XpmPortName) == 0) {
  220.         for (i=0; i < ports->nlines ; i++) {
  221.             if ( StrToPort(ports->lines[i], &p) 
  222.                  && p.x == at_x && p.y == at_y ) {
  223.                 return i;
  224.             }
  225.         }
  226.     }
  227.     return UNKNOWN;
  228. }
  229.  
  230.  
  231. /*--------------------------------------------------------------------------*/
  232. /*
  233.              I s P o r t 
  234.  
  235.     See if a port exists at location (x,y). 
  236. */
  237. /*--------------------------------------------------------------------------*/
  238.  
  239. Boolean IsPort( w, x, y, return_ports, return_port_i )
  240.     Widget       w;
  241.     Position     x;
  242.     Position     y;
  243.     XpmExtension **return_ports;    /* list of ports; can be NULL! */
  244.     int          *return_port_i;    /* index of port x,y; can be NULL! */
  245. {
  246.     Boolean      result = False;
  247.     XpmExtension *ports = NULL;
  248.     int         i;
  249.  
  250.     /* if given a list of ports, use them; else get ports from widget */
  251.     if ( return_ports != NULL && *return_ports != NULL ) 
  252.         ports = *return_ports;
  253.     else 
  254.         ports = PWFindExtension( w, XpmPortName );
  255.     
  256.     if ( ports != NULL ) { 
  257.        if ( (i=FindPort(ports, x, y)) >= 0 ) {
  258.            result = True;
  259.        }
  260.     }
  261.  
  262.     if ( return_port_i != NULL )
  263.         *return_port_i = i;
  264.  
  265.     if ( return_ports != NULL ) 
  266.         *return_ports = ports;
  267.  
  268.     else if ( ports != NULL )
  269.         XpmFreeExtensions( ports, 1 );    /* free ports if caller */
  270.                                         /* doesn't want them    */
  271.     return result;
  272. }
  273.  
  274.  
  275. /*--------------------------------------------------------------------------*/
  276. /*
  277.             A d d P o r t
  278.  
  279.     Add a port to end of list. Return index of new port.
  280. */
  281. /*--------------------------------------------------------------------------*/
  282. int AddPort( ports, at_x, at_y )
  283.     XpmExtension *ports;
  284.     Position     at_x;
  285.     Position     at_y;
  286. {
  287.     Port *p;
  288.     char *port_str;
  289.     int  i = UNKNOWN;
  290.  
  291.     if ((p=NewPort()) != NULL) {
  292.  
  293.         p->x  = at_x;
  294.         p->y  = at_y;
  295.         p->id = 0;        /* mark as new port */
  296.  
  297.         if ( (port_str=PortToStr(p)) != NULL ) {
  298.  
  299.            i = ports->nlines;
  300.            ports->nlines++;
  301.  
  302.            if (ports->lines != NULL)
  303.                ports->lines = (char **) XtRealloc( 
  304.                                            (char *)ports->lines, 
  305.                                            ports->nlines * sizeof(char*) );
  306.            else 
  307.                ports->lines = (char **) XtNew( char** );
  308.  
  309.            ports->lines[i] = port_str;
  310.         }
  311.         XtFree((char *)p);
  312.     }
  313.     return i;
  314. } 
  315.  
  316.  
  317.  
  318. /*--------------------------------------------------------------------------*/
  319. /*
  320.             D e l P o r t
  321.  
  322.     Delete port i. Shift array elements above i to the left.
  323. */
  324. /*--------------------------------------------------------------------------*/
  325. void DelPort( ports, i )
  326.     XpmExtension *ports;
  327.     int          i;
  328. {
  329.     char **s, **t, **last;
  330.  
  331.     XtFree( ports->lines[i] );
  332.  
  333.     last = ports->lines + ports->nlines;    /* last element */
  334.     ports->nlines--;
  335.  
  336.     /* shift left elements above deletion, if necessary */
  337.     if (ports->nlines > 0) 
  338.         for (t = ports->lines+i, s = ports->lines+i+1; s < last; *t++ = *s++);
  339.     else {
  340.         XtFree( (char *)ports->lines );
  341.         ports->lines = NULL;
  342.     }
  343. } 
  344.  
  345.  
  346. /*--------------------------------------------------------------------------*/
  347. /*
  348.             T r a n s l a t e P o r t
  349.  
  350.     Add offsets dx and dy to location of port i.
  351. */
  352. /*--------------------------------------------------------------------------*/
  353. void TranslatePort( ports, port_i, dx, dy )
  354.     XpmExtension *ports;
  355.     int port_i;
  356.     int dx;
  357.     int dy;
  358. {
  359.     Port p;
  360.  
  361.     if ( StrToPort(ports->lines[port_i], &p) ) {
  362.         p.x += dx;
  363.         p.y += dy;
  364.         UpdatePort( ports, port_i, &p );
  365.     }
  366. }
  367.  
  368.  
  369. /*--------------------------------------------------------------------------*/
  370. /*
  371.                         P r i n t P o r t s
  372. */
  373. /*--------------------------------------------------------------------------*/
  374. void PrintPorts( ports )
  375.     XpmExtension *ports;
  376. {
  377.     fprintf( stderr, "ports:\n" );
  378.     if ( ports ) {
  379.         int i;
  380.         for (i = 0; i < ports->nlines; i++) 
  381.             fprintf(stderr, "\t\t%s\n", ports->lines[i]);
  382.     }
  383. }
  384.  
  385.  
  386.  
  387. /*****************************************************************************/
  388. /*
  389.         Port Editor Interface Routines 
  390. */
  391. /*****************************************************************************/
  392.  
  393.  
  394. /*--------------------------------------------------------------------------*/
  395. /*
  396.             P o r t S h a p e
  397.  
  398.     Return an array of points defining a port's shape.
  399. */
  400. /*--------------------------------------------------------------------------*/
  401.  
  402. #define NPortPoints 7
  403.  
  404. XPoint *PortShape( w, x ,y )
  405.     Widget    w;
  406.     Position    x; 
  407.     Position    y;
  408. {
  409.     static XPoint points[NPortPoints];
  410.     int   i;
  411.     float fx = x;
  412.     float fy = y;
  413.  
  414.     points[0].x = PWInWindowX( w, fx );
  415.     points[0].y = PWInWindowY( w, fy );
  416.     points[1].x = PWInWindowX( w, fx + 0.5 );
  417.     points[1].y = PWInWindowY( w, fy + 0.5 );
  418.     points[2].x = PWInWindowX( w, fx );
  419.     points[2].y = PWInWindowY( w, fy + 1 );
  420.     points[3].x = PWInWindowX( w, fx + 1 );
  421.     points[3].y = PWInWindowY( w, fy + 1 );
  422.     points[4].x = PWInWindowX( w, fx + 0.5 );
  423.     points[4].y = PWInWindowY( w, fy + 0.5 );
  424.     points[5].x = PWInWindowX( w, fx + 1 );
  425.     points[5].y = PWInWindowY( w, fy );
  426.     points[6].x = PWInWindowX( w, fx );
  427.     points[6].y = PWInWindowY( w, fy );
  428.  
  429. /*
  430.     fprintf( stderr, "PortShape:\n" );
  431.     for ( i=0; i < NPortPoints; i++ )
  432.         fprintf( stderr, "\t\t%d, %d\n", points[i].x, points[i].y );
  433. */
  434.  
  435.     return points;
  436. }
  437.  
  438.  
  439. /*--------------------------------------------------------------------------*/
  440. /*
  441.             D r a w P o r t 
  442.  
  443.     Just draw a port a location (x,y) with given value (set, clear, 
  444.     invert, or highlight). 
  445. */
  446. /*--------------------------------------------------------------------------*/
  447. #if NeedFunctionPrototypes
  448. void DrawPort(Widget w, Position x, Position y, int value)
  449. #else
  450. void DrawPort(w, x, y, value )
  451.     Widget   w;
  452.     Position x;
  453.     Position y;
  454.     int      value;
  455. #endif
  456. {
  457.     GC gc;
  458.  
  459. /*
  460.     if (_PORTDEBUG)
  461.         printf( "DrawPort: %d %d \n", x, y );
  462. */
  463.  
  464.     gc = (value == Highlight) ? PWHighlightingGC(w) : PWFramingGC(w);
  465.  
  466.     XFillPolygon( XtDisplay(w), XtWindow(w), gc,
  467.                   PortShape(w, x, y), NPortPoints, 
  468.                   Convex, CoordModeOrigin );
  469. }
  470.  
  471.  
  472. /*--------------------------------------------------------------------------*/
  473. /*
  474.             D r a w I f P o r t 
  475.  
  476.     Draw a port at location (x,y) if there is a port at that 
  477.     location. This routine is used to highlight a port that a
  478.     user is trying to pick.
  479. */
  480. /*--------------------------------------------------------------------------*/
  481. #if NeedFunctionPrototypes
  482. void DrawIfPort(Widget w, Position x, Position y, int value )
  483. #else
  484. void DrawIfPort( w, x, y, value )
  485.     Widget   w;
  486.     Position x;
  487.     Position y;
  488.     int      value;
  489. #endif
  490. {
  491.     if ( IsPort(w, x, y, NULL, NULL) )
  492.         DrawPort( w, x, y, value );
  493. } 
  494.  
  495.  
  496. /*--------------------------------------------------------------------------*/
  497. /*
  498.             S e t P o r t 
  499.  
  500.     Create and draw a port at (x,y) if there is not already a port
  501.     there. 
  502. */
  503. /*--------------------------------------------------------------------------*/
  504. #if NeedFunctionPrototypes
  505. void SetPort(Widget w, Position x, Position y, int value )
  506. #else
  507. void SetPort( w, x, y, value )
  508.     Widget   w;
  509.     Position x;
  510.     Position y;
  511.     int      value;
  512. #endif
  513. {
  514.     XpmExtension *ports = NULL;
  515.  
  516.     if (_PORTDEBUG)
  517.         printf( "SetPort: %d,%d \n", x, y );
  518.  
  519.     if ( !IsPort(w, x, y, &ports, NULL) ) {
  520.         if (ports == NULL) {
  521.             PWAddExtension( w, XpmPortName );
  522.             ports = PWFindExtension( w, XpmPortName );
  523.         }
  524.  
  525.         AddPort( ports, x, y );
  526.         DrawPort( w, x, y, value );
  527.  
  528.     if (_PORTDEBUG)
  529.             PrintPorts( ports );
  530.  
  531.         PWUpdateExtension( w, ports );
  532.     XpmFreeExtensions( ports, 1 );
  533.     }
  534. } 
  535.  
  536.  
  537. /*--------------------------------------------------------------------------*/
  538. /*
  539.             C l e a r P o r t 
  540.  
  541.     Delete the port at (x,y) from the port list and erase the port 
  542.     on the screen.
  543. */
  544. /*--------------------------------------------------------------------------*/
  545. #if NeedFunctionPrototypes
  546. void ClearPort(Widget w, Position x, Position y, int value )
  547. #else
  548. void ClearPort( w, x, y, value )
  549.     Widget   w;
  550.     Position x;
  551.     Position y;
  552.     int      value;
  553. #endif
  554. {
  555.     XpmExtension *ports = NULL;
  556.     int          port_i;
  557.  
  558.     if (_PORTDEBUG)
  559.         printf("ClearPort : %d,%d \n", x, y);
  560.  
  561.     if ( IsPort(w, x, y, &ports, &port_i) ) { 
  562.  
  563.         DelPort( ports, port_i );
  564.         DrawPort( w, x, y, value );    /* erase */
  565.  
  566.     if (_PORTDEBUG)
  567.             PrintPorts( ports );
  568.  
  569.         if ( ports->nlines == 0 )
  570.             PWRemoveExtension( w, XpmPortName );
  571.         else
  572.             PWUpdateExtension( w, ports );
  573.     XpmFreeExtensions( ports, 1 );
  574.     }
  575. }
  576.  
  577.  
  578. /*--------------------------------------------------------------------------*/
  579. /*
  580.             D r a g P o r t 
  581.  
  582.     Draw a port while the user is dragging. Draw only if a port existed
  583.     at the starting location of the drag. 
  584. */
  585. /*--------------------------------------------------------------------------*/
  586.  
  587. static struct {
  588.  
  589.     Boolean  b;        /* Are we dragging a port?  */
  590.     Position from_x;    /* starting point of drag   */
  591.     Position from_y;    
  592.     int      port_i;    /* which port is being dragged */
  593.  
  594. } dragging = { False, UNKNOWN, UNKNOWN, UNKNOWN };
  595.  
  596.  
  597. #if NeedFunctionPrototypes
  598. void DragPort(Widget w, Position x, Position y, int value )
  599. #else
  600. void DragPort( w, x, y, value )
  601.     Widget   w;
  602.     Position x;
  603.     Position y;
  604.     int      value;
  605. #endif
  606. {
  607.     int      i;
  608.  
  609.     /* if beginning of drag a port, ... */
  610.     if ( dragging.b == False && IsPort(w, x, y, NULL, &i) ) {
  611.  
  612.         dragging.b      = True;
  613.     dragging.from_x = x;
  614.     dragging.from_y = y;
  615.         dragging.port_i = i;
  616.     }
  617.  
  618.     if (dragging.b) {
  619.         DrawPort( w, dragging.from_x, dragging.from_y, value );/* erase */
  620.         DrawPort( w, x, y, value );/* draw */
  621.     }
  622. }
  623.  
  624. /*--------------------------------------------------------------------------*/
  625. /*
  626.             M o v e P o r t 
  627.  
  628.     Move a port from one location to another after user has completed
  629.     dragging.
  630. */
  631. /*--------------------------------------------------------------------------*/
  632. #if NeedFunctionPrototypes
  633. void MovePort(Widget w, Position to_x, Position to_y, int value )
  634. #else
  635. void MovePort( w, to_x, to_y, value )
  636.     Widget   w;
  637.     Position to_x;
  638.     Position to_y;
  639.     int      value;
  640. #endif
  641. {
  642.     XpmExtension *ports = NULL;
  643.     Port         p;
  644.  
  645.     if (_PORTDEBUG)
  646.         printf("MovePort : from %d,%d to %d,%d \n", 
  647.                 dragging.from_x, dragging.from_y, to_x, to_y);
  648.  
  649.     if ( dragging.b
  650.          && !IsPort(w, to_x, to_y, &ports, NULL)  ) {
  651.  
  652.         DrawPort( w, dragging.from_x, dragging.from_y, value );/* erase old */
  653.         DrawPort( w, to_x, to_y, value );                   /* draw  new */
  654.  
  655.         TranslatePort( ports, dragging.port_i, 
  656.                        to_x - dragging.from_x, 
  657.                        to_y - dragging.from_y  );
  658.  
  659.         PWUpdateExtension( w, ports );
  660.     XpmFreeExtensions( ports, 1 );
  661.     if (_PORTDEBUG)
  662.             PrintPorts( ports );
  663.     }
  664.     dragging.b      = False;
  665.     dragging.from_x = UNKNOWN;
  666.     dragging.from_y = UNKNOWN;
  667.     dragging.port_i = UNKNOWN;
  668. }
  669.  
  670.  
  671. /*--------------------------------------------------------------------------*/
  672. /*
  673.             P o r t I n f o
  674.  
  675.     Allow the user to edit the port information for the port at (x,y).
  676. */
  677. /*--------------------------------------------------------------------------*/
  678.  
  679. #if NeedFunctionPrototypes
  680. void PortInfo(Widget w, Position x, Position y, int value )
  681. #else
  682. void PortInfo( w, x, y, value )
  683.     Widget   w;
  684.     Position x;
  685.     Position y;
  686.     int      value;
  687. #endif
  688. {
  689.     XpmExtension *ports = NULL;
  690.     Port         p;
  691.     int          i;
  692.     char         *newInfo;
  693.  
  694.     if (_PORTDEBUG)
  695.         printf("PortInfo : %d,%d\n", x, y);
  696.  
  697.     if ( IsPort(w, x, y, &ports, &i) ) { 
  698.         StrToPort( ports->lines[i], &p );
  699.         if ( PopupDialog( input_dialog, 
  700.                           "Port Info: <name> <kind>",
  701.                            p.info, &newInfo,
  702.                           XtGrabExclusive) == Okay ) {
  703.         strcpy( p.info, newInfo );
  704.             UpdatePort( ports, i, &p ); 
  705.         }
  706.     if (_PORTDEBUG)
  707.             PrintPorts( ports );
  708.         PWUpdateExtension( w, ports );
  709.     XpmFreeExtensions( ports, 1 );
  710.     }
  711. }
  712.  
  713.  
  714. /*--------------------------------------------------------------------------*/
  715. /*
  716.             R e d r a w P o r t s
  717.  
  718.     Redraw all ports of PixmapWidget.
  719. */
  720. /*--------------------------------------------------------------------------*/
  721.  
  722. void RedrawPorts( w, value )
  723.     Widget w;
  724.     int    value;
  725. {
  726.     XpmExtension *ports = NULL;
  727.     Port         p;
  728.     int          i;
  729.  
  730.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  731.         for ( i=0; i < ports->nlines; i++ ) { 
  732.             StrToPort( ports->lines[i], &p );
  733.             DrawPort( w, p.x, p.y, value ); 
  734.         }
  735.     }
  736. }
  737.  
  738.  
  739. /*--------------------------------------------------------------------------*/
  740. /*
  741.             T r a n s l a t e P o r t s 
  742.  
  743.     For all ports in PixmapWidget, add dx,dy to the ports location.
  744. */
  745. /*--------------------------------------------------------------------------*/
  746.  
  747. void TranslatePorts( w, dx, dy )
  748.     Widget    w;
  749.     Position    dx;
  750.     Position    dy;
  751. {
  752.     XpmExtension *ports = NULL;
  753.     Port         p;
  754.     int          i;
  755.  
  756.     if (_PORTDEBUG)
  757.         printf("TranslatePorts : %d,%d\n", dx, dy);
  758.  
  759.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  760.         for ( i=0; i < ports->nlines; i++ ) { 
  761.             StrToPort( ports->lines[i], &p );
  762.  
  763.             DrawPort( w, p.x, p.y, Clear );        /* erase old */
  764.             PWTranslatePoint( w, &p.x, &p.y, dx, dy ); 
  765.             DrawPort( w, p.x, p.y, Set );        /* draw new */
  766.  
  767.         UpdatePort( ports, i, &p );
  768.         }
  769.     if (_PORTDEBUG)
  770.             PrintPorts( ports );
  771.         PWUpdateExtension( w, ports );
  772.     XpmFreeExtensions( ports, 1 );
  773.     }
  774.  
  775. }
  776.  
  777.  
  778. /*--------------------------------------------------------------------------*/
  779. /*
  780.             F l i p P o r t s 
  781.  
  782.     Flip all ports of a PixmapWidget either horiziontally or vertically.
  783. */
  784. /*--------------------------------------------------------------------------*/
  785.  
  786. void FlipPorts( w, axis  )
  787.     Widget         w;
  788.     enum FlipAxis    axis;
  789. {
  790.     XpmExtension *ports = NULL;
  791.     Port         p;
  792.     int          i;
  793.  
  794.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  795.         for ( i=0; i < ports->nlines; i++ ) { 
  796.             StrToPort( ports->lines[i], &p );
  797.  
  798.             DrawPort( w, p.x, p.y, Clear );        /* erase old */
  799.             PWFlipPoint( w, &p.x, &p.y, axis ); 
  800.             DrawPort( w, p.x, p.y, Set );        /* draw new */
  801.  
  802.         UpdatePort( ports, i, &p );
  803.         }
  804.     if (_PORTDEBUG)
  805.             PrintPorts( ports );
  806.         PWUpdateExtension( w, ports );
  807.     XpmFreeExtensions( ports, 1 );
  808.     }
  809. }
  810.  
  811.  
  812. /*--------------------------------------------------------------------------*/
  813. /*
  814.             R o t a t e P o r t s 
  815.  
  816.     Flip all ports of a PixmapWidget either left or right 90 degrees.
  817. */
  818. /*--------------------------------------------------------------------------*/
  819.  
  820. void RotatePorts( w, direction )
  821.     Widget            w;
  822.     enum RotateDirection    direction;
  823. {
  824.     XpmExtension *ports = NULL;
  825.     Port         p;
  826.     int          i;
  827.  
  828.     if ( (ports=PWFindExtension( w, XpmPortName )) != NULL ) { 
  829.         for ( i=0; i < ports->nlines; i++ ) { 
  830.             StrToPort( ports->lines[i], &p );
  831.  
  832.             DrawPort( w, p.x, p.y, Clear );        /* erase old */
  833.             PWRotatePoint( w, &p.x, &p.y, direction ); 
  834.             DrawPort( w, p.x, p.y, Set );        /* draw new */
  835.  
  836.         UpdatePort( ports, i, &p );
  837.         }
  838.     if (_PORTDEBUG)
  839.             PrintPorts( ports );
  840.         PWUpdateExtension( w, ports );
  841.     XpmFreeExtensions( ports, 1 );
  842.     }
  843. }
  844.  
  845.  
  846. /*--------------------------------------------------------------------------*/
  847. /*
  848.             P o r t E d i t o r C a l l b a c k
  849.  
  850.     Callback for all port editor buttons
  851. */
  852. /*--------------------------------------------------------------------------*/
  853. void PortEditorCallback( w, client_data, call_data )
  854.     Widget w;
  855.     XtPointer client_data, call_data;
  856. {
  857.     int *id = (int *)client_data;
  858.  
  859.     switch (*id) {
  860.  
  861.  
  862.     case kSetPort:
  863.     if (_PORTDEBUG)
  864.             printf( "PortEditorCallback: %s\n", portEditorButtons[*id].name );
  865.         PWRemoveAllRequests( pixmap_widget );
  866.  
  867.     PWSetPickPixelDrawProc( pixmap_widget, DrawPort );
  868.     PWSetPickPixelCompleteProc( pixmap_widget, SetPort );
  869.  
  870.         PWEngageRequest( pixmap_widget, PickPixelRequest, True, Plain );
  871.         break;
  872.  
  873.     case kClearPort:
  874.     if (_PORTDEBUG)
  875.             printf( "PortEditorCallback: %s\n", portEditorButtons[*id].name );
  876.         PWRemoveAllRequests( pixmap_widget );
  877.  
  878.     PWSetPickPixelDrawProc( pixmap_widget, DrawIfPort );
  879.     PWSetPickPixelCompleteProc( pixmap_widget, ClearPort );
  880.  
  881.         PWEngageRequest( pixmap_widget, PickPixelRequest, True, Plain );
  882.         break;
  883.  
  884.     case kMovePort:
  885.     if (_PORTDEBUG)
  886.             printf( "PortEditorCallback: %s\n", portEditorButtons[*id].name );
  887.         PWRemoveAllRequests( pixmap_widget );
  888.  
  889.     PWSetPickPixelDrawProc( pixmap_widget, DragPort );
  890.     PWSetPickPixelCompleteProc( pixmap_widget, MovePort );
  891.  
  892.         PWEngageRequest( pixmap_widget, PickPixelRequest, True, Plain );
  893.     break;
  894.  
  895.     case kPortInfo:
  896.     if (_PORTDEBUG)
  897.             printf( "PortEditorCallback: %s\n", portEditorButtons[*id].name );
  898.         PWRemoveAllRequests( pixmap_widget );
  899.  
  900.     PWSetPickPixelDrawProc( pixmap_widget, DrawIfPort );
  901.     PWSetPickPixelCompleteProc( pixmap_widget, PortInfo );
  902.  
  903.         PWEngageRequest( pixmap_widget, PickPixelRequest, True, Plain );
  904.     break;
  905.  
  906.     default:
  907.         printf( "PortEditorCallback: invalid id = %d\n", *id );
  908.     } /* switch */
  909.  
  910. } /* PortEditorCallback */
  911.  
  912.  
  913.  
  914. /*--------------------------------------------------------------------------*/
  915. /*
  916.         C r e a t e P o r t E d i t o r B u t t o n s
  917.  
  918.     Create buttons of port editor.
  919. */
  920. /*--------------------------------------------------------------------------*/
  921. void CreatePortEditorButtons( parentW, radioGroupW )
  922.     Widget    parentW;    /* parent widget of port editor buttons */
  923.     Widget    radioGroupW;    /* radio group to add port editor buttons */
  924. {
  925.     int    i;
  926.     Widget w;
  927.  
  928.     for (i = 0; i < XtNumber(portEditorButtons); i++) {
  929.  
  930. #ifndef USE_ATHENA
  931.     w = XmCreateToggleButtonGadget(parentW, portEditorButtons[i].name,
  932.                        NULL, 0);
  933.     XtManageChild(w);
  934.         portEditorButtons[i].widget = w;
  935.  
  936.         XtAddCallback(w, XmNvalueChangedCallback, PortEditorCallback,
  937.               &portEditorButtons[i].id );
  938.     
  939. #else
  940.         w = XtCreateWidget( portEditorButtons[i].name,
  941.                             toggleWidgetClass,
  942.                             parentW, NULL, 0 );
  943.  
  944.         portEditorButtons[i].widget = w;
  945.  
  946.         XtAddCallback( w, 
  947.                XtNcallback, PortEditorCallback,
  948.                        &portEditorButtons[i].id );
  949.  
  950.     /* add to button to radio group */
  951.     XtVaSetValues( w,
  952.                XtNradioGroup, radioGroupW,
  953.                NULL );
  954. #endif
  955.     } 
  956. } 
  957.  
  958.  
  959.  
  960. /*--------------------------------------------------------------------------*/
  961. /*
  962.         M a n a g e P o r t E d i t o r B u t t o n s
  963.  
  964.     Manage or unmanage the buttons of port editor depending on flag.
  965. */
  966. /*--------------------------------------------------------------------------*/
  967. void ManagePortEditorButtons( manage )
  968.     Boolean    manage;        /* if true, manage; otherwise unmanage */
  969. {
  970.     int    i;
  971.     Widget w;
  972.  
  973.     for (i = 0; i < XtNumber(portEditorButtons); i++) {
  974.     if (manage) 
  975.             XtManageChild( portEditorButtons[i].widget );
  976.         else 
  977.             XtUnmanageChild( portEditorButtons[i].widget );
  978.     } 
  979. }
  980.  
  981.  
  982.  
  983.